package devcontainer

import (
	"encoding/json"
	"fmt"
	"regexp"
	"strconv"
	"strings"
)

// DevContainerConfiguration 表示 devcontainer.json 的根配置
type DevContainerConfiguration struct {
	// ----------------------------
	// 通用属性 (General properties)
	// ----------------------------
	Name                        string                     `json:"name,omitempty"`                        // 容器名称
	ForwardPorts                []interface{}              `json:"forwardPorts,omitempty"`                // 要转发的端口（整数或字符串）
	PortsAttributes             map[string]PortAttribute   `json:"portsAttributes,omitempty"`             // 端口特性配置
	OtherPortsAttributes        map[string]PortAttribute   `json:"otherPortsAttributes,omitempty"`        // 其他端口特性配置
	ContainerEnv                map[string]string          `json:"containerEnv,omitempty"`                // 容器环境变量
	RemoteEnv                   map[string]string          `json:"remoteEnv,omitempty"`                   // 远程环境变量
	RemoteUser                  string                     `json:"remoteUser,omitempty"`                  // 远程用户
	ContainerUser               string                     `json:"containerUser,omitempty"`               // 容器用户
	UpdateRemoteUserUID         bool                       `json:"updateRemoteUserUID,omitempty"`         // 是否更新远程用户UID
	UserEnvProbe                string                     `json:"userEnvProbe,omitempty"`                // 用户环境探测方式（枚举值）
	OverrideCommand             bool                       `json:"overrideCommand,omitempty"`             // 是否覆盖默认命令
	ShutdownAction              string                     `json:"shutdownAction,omitempty"`              // 关闭动作（枚举值）
	Init                        bool                       `json:"init,omitempty"`                        // 是否使用init进程
	Privileged                  bool                       `json:"privileged,omitempty"`                  // 是否特权模式
	CapAdd                      []string                   `json:"capAdd,omitempty"`                      // 添加的Linux能力
	SecurityOpt                 []string                   `json:"securityOpt,omitempty"`                 // 安全选项
	Mounts                      []interface{}              `json:"mounts,omitempty"`                      // 挂载配置（字符串或对象）
	Features                    map[string]json.RawMessage `json:"features,omitempty"`                    // 功能特性配置
	OverrideFeatureInstallOrder []string                   `json:"overrideFeatureInstallOrder,omitempty"` // 特性安装顺序覆盖
	Customizations              map[string]interface{}     `json:"customizations,omitempty"`              // 自定义配置

	// --------------------------------------
	// 镜像/Dockerfile 相关属性 (Image/Dockerfile)
	// --------------------------------------
	Image           string      `json:"image,omitempty"`           // 使用的镜像
	Build           *Build      `json:"build,omitempty"`           // Docker构建配置
	AppPort         interface{} `json:"appPort,omitempty"`         // 应用端口（整数/字符串/数组）
	WorkspaceMount  string      `json:"workspaceMount,omitempty"`  // 工作区挂载点
	WorkspaceFolder string      `json:"workspaceFolder,omitempty"` // 工作区目录
	RunArgs         []string    `json:"runArgs,omitempty"`         // 容器运行参数

	// ----------------------------------
	// Docker Compose 相关属性 (Docker Compose)
	// ----------------------------------
	DockerComposeFile StringOrArray `json:"dockerComposeFile,omitempty"` // Compose文件路径（字符串或数组）
	Service           string        `json:"service,omitempty"`           // 使用的服务名
	RunServices       []string      `json:"runServices,omitempty"`       // 要运行的服务

	// ---------------------------
	// 生命周期命令 (Lifecycle commands)
	// ---------------------------
	InitializeCommand    interface{} `json:"initializeCommand,omitempty"`    // 初始化命令（字符串/数组/对象）
	OnCreateCommand      interface{} `json:"onCreateCommand,omitempty"`      // 创建后命令（字符串/数组/对象）
	UpdateContentCommand interface{} `json:"updateContentCommand,omitempty"` // 内容更新命令（字符串/数组/对象）
	PostCreateCommand    interface{} `json:"postCreateCommand,omitempty"`    // 创建完成命令（字符串/数组/对象）
	PostStartCommand     interface{} `json:"postStartCommand,omitempty"`     // 启动后命令（字符串/数组/对象）
	PostAttachCommand    interface{} `json:"postAttachCommand,omitempty"`    // 连接后命令（字符串/数组/对象）
	WaitFor              string      `json:"waitFor,omitempty"`              // 等待事件（枚举值）

	// ---------------------------
	// 主机要求 (Host requirements)
	// ---------------------------
	HostRequirements *HostRequirements `json:"hostRequirements,omitempty"` // 主机资源要求
}

// PortAttribute 端口特性配置
type PortAttribute struct {
	Label            string `json:"label,omitempty"`            // 端口标签
	Protocol         string `json:"protocol,omitempty"`         // 协议类型（枚举值）
	OnAutoForward    string `json:"onAutoForward,omitempty"`    // 自动转发行为（枚举值）
	RequireLocalPort bool   `json:"requireLocalPort,omitempty"` // 是否需要本地端口
	ElevateIfNeeded  bool   `json:"elevateIfNeeded,omitempty"`  // 需要时是否提权
}

// Build Docker构建配置
type Build struct {
	Dockerfile string            `json:"dockerfile,omitempty"` // Dockerfile路径
	Context    string            `json:"context,omitempty"`    // 构建上下文
	Args       map[string]string `json:"args,omitempty"`       // 构建参数
	Options    []string          `json:"options,omitempty"`    // 构建选项
	Target     string            `json:"target,omitempty"`     // 构建目标阶段
	CacheFrom  StringOrArray     `json:"cacheFrom,omitempty"`  // 缓存来源（字符串或数组）
}

// HostRequirements 主机资源要求
type HostRequirements struct {
	CPUs    int         `json:"cpus,omitempty"`    // CPU核心数
	Memory  string      `json:"memory,omitempty"`  // 内存要求（如"8GB"）
	Storage string      `json:"storage,omitempty"` // 存储要求（如"100GB"）
	GPU     interface{} `json:"gpu,omitempty"`     // GPU要求（布尔/字符串/对象）
}

// StringOrArray 处理字符串或数组类型的自定义类型
type StringOrArray []string

// MarshalJSON 自定义JSON序列化（单个值时输出字符串）
func (s StringOrArray) MarshalJSON() ([]byte, error) {
	if len(s) == 1 {
		return json.Marshal(s[0])
	}
	return json.Marshal([]string(s))
}

// UnmarshalJSON 自定义JSON反序列化
func (s *StringOrArray) UnmarshalJSON(data []byte) error {
	// 尝试解析为字符串
	var single string
	if err := json.Unmarshal(data, &single); err == nil {
		*s = []string{single}
		return nil
	}

	// 尝试解析为字符串数组
	var multi []string
	if err := json.Unmarshal(data, &multi); err == nil {
		*s = multi
		return nil
	}

	return json.Unmarshal(data, &multi)
}

// Unmarshal 反序列化JSON
func UnmarshalDevcontainerConfigContent(devcontainerConfigContent string) (*DevContainerConfiguration, error) {
	// 1. 初始化
	devcontainerObject := &DevContainerConfiguration{}
	// 2. JSON 反序列化
	err := json.Unmarshal([]byte(devcontainerConfigContent), devcontainerObject)
	if err != nil {
		return nil, err
	}
	// 3. 返回
	return devcontainerObject, err
}

// 定义允许的枚举值集合
var (
	validUserEnvProbe      = []string{"none", "interactiveShell", "loginShell"}
	validShutdownActions   = []string{"none", "stopContainer"}
	validPortProtocols     = []string{"http", "https", "none"}
	validOnAutoForwardOpts = []string{"notify", "openBrowser", "openPreview", "ignore", "silent"}
	validWaitForEvents     = []string{"init", "create", "attach"}
)

// Validate 验证 DevContainerConfiguration 的合法性
func (c *DevContainerConfiguration) Validate() []error {
	var errors []error

	// 1. 基本字段验证
	errors = append(errors, c.validateBasicFields()...)

	// 2. 端口相关验证
	errors = append(errors, c.validatePorts()...)

	// 3. 构建配置验证
	errors = append(errors, c.validateBuildConfig()...)

	// 4. Docker Compose 配置验证
	errors = append(errors, c.validateDockerCompose()...)

	// 5. 生命周期命令验证
	errors = append(errors, c.validateLifecycleCommands()...)

	// 6. 主机要求验证
	errors = append(errors, c.validateHostRequirements()...)

	// 7. 互斥字段验证
	errors = append(errors, c.validateMutuallyExclusive()...)
	// 8. RunArgs字段验证
	errors = append(errors, c.ValidateRunArgs()...)

	return errors
}

// 验证基本字段
func (c *DevContainerConfiguration) validateBasicFields() []error {
	var errors []error

	// 名称验证
	if c.Name == "" {
		errors = append(errors, fmt.Errorf("name is required"))
	} else if len(c.Name) > 100 {
		errors = append(errors, fmt.Errorf("name exceeds maximum length of 100 characters"))
	}

	// 枚举值验证
	errors = append(errors, validateEnum("userEnvProbe", c.UserEnvProbe, validUserEnvProbe)...)
	errors = append(errors, validateEnum("shutdownAction", c.ShutdownAction, validShutdownActions)...)

	// 用户ID更新验证
	if c.UpdateRemoteUserUID && (c.RemoteUser == "" && c.ContainerUser == "") {
		errors = append(errors,
			fmt.Errorf("updateRemoteUserUID requires either remoteUser or containerUser to be set"))
	}

	// 挂载点验证
	for i, mount := range c.Mounts {
		switch m := mount.(type) {
		case string:
			if !isValidMountString(m) {
				errors = append(errors,
					fmt.Errorf("mount[%d]: invalid mount format '%s'", i, m))
			}
		case map[string]interface{}:
			// 更详细的对象挂载验证
			if _, ok := m["source"]; !ok {
				errors = append(errors,
					fmt.Errorf("mount[%d]: missing 'source' property", i))
			}
			if _, ok := m["target"]; !ok {
				errors = append(errors,
					fmt.Errorf("mount[%d]: missing 'target' property", i))
			}
		default:
			errors = append(errors,
				fmt.Errorf("mount[%d]: must be string or object", i))
		}
	}

	return errors
}

// 验证端口相关配置
func (c *DevContainerConfiguration) validatePorts() []error {
	var errors []error

	// 转发端口格式验证
	for i, port := range c.ForwardPorts {
		switch p := port.(type) {
		case int:
			if p <= 0 || p > 65535 {
				errors = append(errors,
					fmt.Errorf("forwardPorts[%d]: port number %d out of range", i, p))
			}
		case string:
			if !isValidPortSpec(p) {
				errors = append(errors,
					fmt.Errorf("forwardPorts[%d]: invalid port specification '%s'", i, p))
			}
		default:
			errors = append(errors,
				fmt.Errorf("forwardPorts[%d]: must be integer or string", i))
		}
	}

	// 应用端口格式验证
	if c.AppPort != nil {
		switch appPort := c.AppPort.(type) {
		case int:
			if appPort <= 0 || appPort > 65535 {
				errors = append(errors,
					fmt.Errorf("appPort: port number %d out of range", appPort))
			}
		case string:
			if !isValidPortSpec(appPort) {
				errors = append(errors,
					fmt.Errorf("appPort: invalid port specification '%s'", appPort))
			}
		case []interface{}:
			for i, port := range appPort {
				switch p := port.(type) {
				case int:
					if p <= 0 || p > 65535 {
						errors = append(errors,
							fmt.Errorf("appPort[%d]: port number %d out of range", i, p))
					}
				case string:
					if !isValidPortSpec(p) {
						errors = append(errors,
							fmt.Errorf("appPort[%d]: invalid port specification '%s'", i, p))
					}
				default:
					errors = append(errors,
						fmt.Errorf("appPort[%d]: must be integer or string", i))
				}
			}
		default:
			errors = append(errors,
				fmt.Errorf("appPort: must be integer, string, or array of port specifications"))
		}
	}

	// 端口属性验证
	validatePortAttributes := func(attrs map[string]PortAttribute, prefix string) {
		for port, attr := range attrs {
			// 验证端口格式
			if !isValidPortSpec(port) {
				errors = append(errors,
					fmt.Errorf("%s: key '%s' is not a valid port specification", prefix, port))
			}

			// 验证属性
			errors = append(errors,
				validateEnum(prefix+"."+port+".protocol", attr.Protocol, validPortProtocols)...)
			errors = append(errors,
				validateEnum(prefix+"."+port+".onAutoForward", attr.OnAutoForward, validOnAutoForwardOpts)...)
		}
	}

	validatePortAttributes(c.PortsAttributes, "portsAttributes")
	validatePortAttributes(c.OtherPortsAttributes, "otherPortsAttributes")

	return errors
}

// 验证构建配置
func (c *DevContainerConfiguration) validateBuildConfig() []error {
	var errors []error

	if c.Build != nil {
		// Dockerfile 路径验证
		if c.Build.Dockerfile == "" {
			errors = append(errors, fmt.Errorf("build.dockerfile is required when using build configuration"))
		}

		// 构建目标验证
		if c.Build.Target != "" && !isValidIdentifier(c.Build.Target) {
			errors = append(errors,
				fmt.Errorf("build.target: invalid target name '%s'", c.Build.Target))
		}

		// 构建参数验证
		for argName := range c.Build.Args {
			if !isValidEnvVarName(argName) {
				errors = append(errors,
					fmt.Errorf("build.args: invalid argument name '%s'", argName))
			}
		}
	}

	return errors
}

// 验证 Docker Compose 配置
func (c *DevContainerConfiguration) validateDockerCompose() []error {
	var errors []error

	if len(c.DockerComposeFile) > 0 {
		// 服务名验证
		if c.Service == "" {
			errors = append(errors,
				fmt.Errorf("service is required when using dockerComposeFile"))
		} else if !isValidServiceName(c.Service) {
			errors = append(errors,
				fmt.Errorf("service: invalid service name '%s'", c.Service))
		}

		// 运行服务验证
		for i, svc := range c.RunServices {
			if !isValidServiceName(svc) {
				errors = append(errors,
					fmt.Errorf("runServices[%d]: invalid service name '%s'", i, svc))
			}
		}
	}

	return errors
}

// 验证生命周期命令
func (c *DevContainerConfiguration) validateLifecycleCommands() []error {
	var errors []error

	validateCommand := func(name string, cmd interface{}) {
		switch cmd.(type) {
		case nil:
			// 允许为空
		case string:
			// 空字符串视为有效
		case []interface{}:
			// 验证数组元素都是字符串
			arr := cmd.([]interface{})
			for i, item := range arr {
				if _, ok := item.(string); !ok {
					errors = append(errors,
						fmt.Errorf("%s[%d]: must be string", name, i))
				}
			}
		case map[string]interface{}:
			// 验证命令对象结构
			cmdObj := cmd.(map[string]interface{})
			if _, ok := cmdObj["command"]; !ok {
				if pathValue, hasPath := cmdObj["path"]; !hasPath {
					errors = append(errors,
						fmt.Errorf("%s: command object requires either 'command' or 'path' property", name))
				} else if hasPath {
					// 如果存在 path，检查它是否为字符串
					if _, ok := pathValue.(string); !ok {
						errors = append(errors,
							fmt.Errorf("%s: 'path' must be a string, got %T", name, pathValue))
					}
				}
			}
		default:
			errors = append(errors,
				fmt.Errorf("%s: must be string, array of strings, or command object", name))
		}
	}

	validateCommand("initializeCommand", c.InitializeCommand)
	validateCommand("onCreateCommand", c.OnCreateCommand)
	validateCommand("updateContentCommand", c.UpdateContentCommand)
	validateCommand("postCreateCommand", c.PostCreateCommand)
	validateCommand("postStartCommand", c.PostStartCommand)
	validateCommand("postAttachCommand", c.PostAttachCommand)

	// 等待事件验证
	errors = append(errors, validateEnum("waitFor", c.WaitFor, validWaitForEvents)...)

	return errors
}

// 验证主机要求
func (c *DevContainerConfiguration) validateHostRequirements() []error {
	var errors []error

	if c.HostRequirements != nil {
		// CPU 验证
		if c.HostRequirements.CPUs < 0 {
			errors = append(errors,
				fmt.Errorf("hostRequirements.cpus: must be positive integer"))
		}

		// 内存格式验证
		if c.HostRequirements.Memory != "" {
			if !isValidMemorySpec(c.HostRequirements.Memory) {
				errors = append(errors,
					fmt.Errorf("hostRequirements.memory: invalid format '%s'", c.HostRequirements.Memory))
			}
		}

		// 存储格式验证
		if c.HostRequirements.Storage != "" {
			if !isValidStorageSpec(c.HostRequirements.Storage) {
				errors = append(errors,
					fmt.Errorf("hostRequirements.storage: invalid format '%s'", c.HostRequirements.Storage))
			}
		}

		// GPU 验证
		switch gpu := c.HostRequirements.GPU.(type) {
		case bool:
			// 布尔值有效
		case string:
			if !isValidGPUDriver(gpu) {
				errors = append(errors,
					fmt.Errorf("hostRequirements.gpu: unsupported driver '%s'", gpu))
			}
		case map[string]interface{}:
			// 验证 GPU 对象结构
			if _, ok := gpu["count"]; !ok {
				errors = append(errors,
					fmt.Errorf("hostRequirements.gpu: object requires 'count' property"))
			}
		case nil:
			// 允许为空
		default:
			errors = append(errors,
				fmt.Errorf("hostRequirements.gpu: must be boolean, string, or object"))
		}
	}

	return errors
}

// 验证互斥字段
func (c *DevContainerConfiguration) validateMutuallyExclusive() []error {
	var errors []error

	// 镜像和构建配置互斥
	if c.Image != "" && c.Build != nil {
		errors = append(errors,
			fmt.Errorf("cannot specify both 'image' and 'build' properties"))
	}

	// Docker Compose 和镜像/构建互斥
	if len(c.DockerComposeFile) > 0 && (c.Image != "" || c.Build != nil) {
		errors = append(errors,
			fmt.Errorf("cannot specify 'dockerComposeFile' with 'image' or 'build'"))
	}

	// 工作区挂载和工作区文件夹共存验证
	if c.WorkspaceMount != "" && c.WorkspaceFolder != "" {
		errors = append(errors,
			fmt.Errorf("'workspaceMount' and 'workspaceFolder' should not be used together"))
	}

	return errors
}

// ================ 辅助验证函数 ================

// 验证枚举值
func validateEnum(fieldName, value string, validValues []string) []error {
	if value == "" {
		return nil
	}

	for _, valid := range validValues {
		if value == valid {
			return nil
		}
	}

	return []error{fmt.Errorf("%s: invalid value '%s', valid options: %v",
		fieldName, value, validValues)}
}

// 验证端口规范格式 (支持 "8080" 或 "8080:80")
func isValidPortSpec(spec string) bool {
	parts := strings.Split(spec, ":")
	if len(parts) > 2 {
		return false
	}

	for _, part := range parts {
		port, err := strconv.Atoi(part)
		if err != nil || port <= 0 || port > 65535 {
			return false
		}
	}
	return true
}

// 验证挂载字符串格式 (支持 "source:target" 或 "source:target:ro")
func isValidMountString(mount string) bool {
	parts := strings.Split(mount, ":")
	if len(parts) < 2 || len(parts) > 3 {
		return false
	}

	// 验证选项（如果存在）
	if len(parts) == 3 {
		options := strings.Split(parts[2], ",")
		for _, opt := range options {
			switch opt {
			case "ro", "rw", "consistent", "cached", "delegated":
				// 有效选项
			default:
				return false
			}
		}
	}

	return true
}

// 验证环境变量名格式
func isValidEnvVarName(name string) bool {
	match, _ := regexp.MatchString(`^[a-zA-Z_][a-zA-Z0-9_]*$`, name)
	return match
}

// 验证服务名格式
func isValidServiceName(name string) bool {
	match, _ := regexp.MatchString(`^[a-z0-9][a-z0-9_-]*$`, name)
	return match
}

// 验证内存规格格式 (如 "4G", "512M")
func isValidMemorySpec(mem string) bool {
	re := regexp.MustCompile(`^\d+[KMGTP]?B?$`)
	return re.MatchString(strings.ToUpper(mem))
}

// 验证存储规格格式 (如 "100GB", "512MB")
func isValidStorageSpec(storage string) bool {
	re := regexp.MustCompile(`^\d+[KMGTP]B$`)
	return re.MatchString(strings.ToUpper(storage))
}

// 验证GPU驱动名
func isValidGPUDriver(driver string) bool {
	validDrivers := []string{"nvidia", "amd", "intel"}
	for _, d := range validDrivers {
		if strings.EqualFold(driver, d) {
			return true
		}
	}
	return false
}

// isValidIdentifier 验证 Docker 构建目标名称的合法性
// Docker 目标名称必须遵循以下规则：
// 1. 只能包含小写字母、数字、下划线、连字符和点号
// 2. 必须以字母或数字开头
// 3. 不能超过 128 个字符
func isValidIdentifier(name string) bool {
	if name == "" {
		return false
	}

	// 长度限制 (Docker 规范)
	if len(name) > 128 {
		return false
	}

	// 检查首字符
	firstChar := name[0]
	if !((firstChar >= 'a' && firstChar <= 'z') ||
		(firstChar >= '0' && firstChar <= '9')) {
		return false
	}

	// 检查所有字符
	for _, r := range name {
		if !(r >= 'a' && r <= 'z') &&
			!(r >= '0' && r <= '9') &&
			r != '_' &&
			r != '-' &&
			r != '.' {
			return false
		}
	}

	// 禁止的特殊序列
	forbiddenSequences := []string{"..", "__", "--", ".-", "-."}
	for _, seq := range forbiddenSequences {
		if strings.Contains(name, seq) {
			return false
		}
	}

	return true
}

// ExtractContainerPorts 从 DevContainerConfiguration 的 ForwardPorts 中提取容器端口
func (c *DevContainerConfiguration) ExtractContainerPorts() []int {
	var containerPorts []int

	for _, port := range c.ForwardPorts {
		switch p := port.(type) {
		case int:
			// 如果是整数，既是主机端口也是容器端口
			if p > 0 && p <= 65535 {
				containerPorts = append(containerPorts, p)
			}
		case string:
			// 解析端口映射格式 "hostPort:containerPort" 或单一端口
			parts := strings.Split(p, ":")
			if len(parts) == 1 {
				// 单一端口，既是主机端口也是容器端口
				if portNum, err := strconv.Atoi(parts[0]); err == nil && portNum > 0 && portNum <= 65535 {
					containerPorts = append(containerPorts, portNum)
				}
			} else if len(parts) == 2 {
				// 端口映射格式 "hostPort:containerPort"，取容器端口（第二个部分）
				if containerPort, err := strconv.Atoi(parts[1]); err == nil && containerPort > 0 && containerPort <= 65535 {
					containerPorts = append(containerPorts, containerPort)
				}
			}
		}
	}

	return containerPorts
}

// GetAllMountOptions 获取所有挂载选项的详细信息
func (c *DevContainerConfiguration) GetAllMountOptions() []map[string]interface{} {
	var mountOptions []map[string]interface{}

	for _, mount := range c.Mounts {
		switch m := mount.(type) {
		case string:
			// 对于字符串格式，简单解析
			parts := strings.Split(m, ":")
			option := map[string]interface{}{
				"source": parts[0],
				"target": parts[1],
			}
			if len(parts) > 2 {
				option["options"] = parts[2]
			}
			mountOptions = append(mountOptions, option)
		case map[string]interface{}:
			mountOptions = append(mountOptions, m)
		}
	}

	return mountOptions
}

// ExtractMountFlags 将 Mounts 字段转换为 -v 参数字符串列表
func (c *DevContainerConfiguration) ExtractMountFlags() []string {
	var mountFlags []string

	// 遍历 Mounts 列表中的每个挂载项
	for _, mount := range c.Mounts {
		switch m := mount.(type) {
		case string:
			// 字符串格式的挂载，直接转换为 -v 格式
			mountFlags = append(mountFlags, fmt.Sprintf("-v %s", m))
		case map[string]interface{}:
			// 对象格式的挂载，需要解析并转换
			if flag := convertMountObjectToFlag(m); flag != "" {
				mountFlags = append(mountFlags, fmt.Sprintf("-v %s", flag))
			}
		}
	}

	return mountFlags
}

// convertMountObjectToFlag 将挂载对象转换为 -v 标志字符串
func convertMountObjectToFlag(mount map[string]interface{}) string {
	// 提取必需的 source 和 target 字段
	source, sourceOk := mount["source"].(string)
	target, targetOk := mount["target"].(string)

	if !sourceOk || !targetOk {
		return ""
	}

	// 构建基本挂载字符串
	mountStr := fmt.Sprintf("%s:%s", source, target)

	// 添加可选的只读标志
	if readOnly, ok := mount["readOnly"].(bool); ok && readOnly {
		mountStr = fmt.Sprintf("%s:ro", mountStr)
	}

	// 添加可选的 consistency 字段（如果存在）
	if consistency, ok := mount["consistency"].(string); ok {
		switch consistency {
		case "consistent", "cached", "delegated":
			mountStr = fmt.Sprintf("%s:%s", mountStr, consistency)
		}
	}

	return mountStr
}

// ValidateRunArgs 验证 RunArgs 字段中的参数是否有效
func (c *DevContainerConfiguration) ValidateRunArgs() []error {
	var errors []error

	// 常见的有效 Docker 运行参数前缀
	validArgPrefixes := []string{
		"--network=", "--net=",
		"--ipc=",
		"--pid=",
		"--user=", "-u ",
		"--group-add=",
		"--ulimit=",
		"--sysctl=",
		"--tmpfs=",
		"--volume=", "-v ",
		"--mount=",
		"--device=",
		"--cap-add=",
		"--cap-drop=",
		"--security-opt=",
		"--env=", "-e ",
		"--env-file=",
		"--hostname=", "-h ",
		"--domainname=",
		"--mac-address=",
		"--memory=", "-m ",
		"--memory-swap=",
		"--memory-swappiness=",
		"--oom-kill-disable",
		"--oom-score-adj=",
		"--restart=",
		"--cpu-shares=",
		"--cpu-period=",
		"--cpu-quota=",
		"--cpuset-cpus=",
		"--cpuset-mems=",
		"--blkio-weight=",
		"--blkio-weight-device=",
		"--device-read-bps=",
		"--device-write-bps=",
		"--device-read-iops=",
		"--device-write-iops=",
		"--kernel-memory=",
		"--memory-reservation=",
		"--pids-limit=",
		"--publish=", "-p ",
		"--publish-all=", "-P",
		"--expose=",
		"--link=",
		"--dns=",
		"--dns-option=",
		"--dns-search=",
		"--add-host=",
		"--cgroup-parent=",
		"--init",
		"--init-path=",
		"--isolation=",
		"--label=", "-l ",
		"--label-file=",
		"--log-driver=",
		"--log-opt=",
		"--name=",
		"--workdir=", "-w ",
	}

	for i, arg := range c.RunArgs {
		// 检查参数是否以有效的前缀开头
		isValid := false
		for _, prefix := range validArgPrefixes {
			if strings.HasPrefix(arg, prefix) {
				isValid = true
				break
			}
		}

		// 一些独立的标志参数
		standaloneFlags := []string{
			"--init", "-i", "-t", "-it", "--privileged",
			"--read-only", "--rm", "--sig-proxy", "--tty",
			"--interactive", "--detach", "-d",
		}

		for _, flag := range standaloneFlags {
			if arg == flag {
				isValid = true
				break
			}
		}

		if !isValid && !strings.HasPrefix(arg, "-") {
			// 可能是值而不是参数，这取决于上下文
			// 这里我们允许非参数开头的值
			isValid = true
		}

		if !isValid {
			errors = append(errors, fmt.Errorf("runArgs[%d]: invalid docker argument '%s'", i, arg))
		}
	}

	return errors
}

// parseCommand 解析不同格式的命令
func (c *DevContainerConfiguration) ParseCommand(command interface{}) []string {
	var commands []string

	switch cmd := command.(type) {
	case string:
		if cmd != "" {
			commands = append(commands, cmd)
		}
	case []interface{}:
		var cmdParts []string
		for _, part := range cmd {
			if str, ok := part.(string); ok {
				cmdParts = append(cmdParts, str)
			} else {
				return nil
			}
		}
		if len(cmdParts) > 0 {
			commands = cmdParts
		}
	case map[string]interface{}:
		// 处理对象格式的命令
		if commandField, ok := cmd["command"]; ok {
			subCommands := c.ParseCommand(commandField)
			commands = append(commands, subCommands...)
		}
	default:
		return nil
	}

	return commands
}
